C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 1   


C51 COMPILER V8.05a, COMPILATION OF MODULE PEDALERA
OBJECT MODULE PLACED IN pedalera.OBJ
COMPILER INVOKED BY: C:\Keil\C51\BIN\C51.EXE pedalera.c BROWSE DEBUG OBJECTEXTEND

line level    source

   1          //-----------------------------------------------------------------------------
   2          //   File:      bulkloop.c
   3          //   Contents:  Hooks required to implement USB peripheral function.
   4          //
   5          // $Archive: /USB/Examples/FX2LP/bulkloop/bulkloop.c $
   6          // $Date: 3/23/05 2:55p $
   7          // $Revision: 4 $
   8          //
   9          //
  10          //-----------------------------------------------------------------------------
  11          // Copyright 2003, Cypress Semiconductor Corporation
  12          //-----------------------------------------------------------------------------
  13          #pragma NOIV               // Do not generate interrupt vectors
  14          
  15          #include "fx2.h"
  16          #include "fx2regs.h"
  17          #include "syncdly.h"            // SYNCDELAY macro
  18          #include "interrupciones.h"     // Rutinas de interrupción
  19          #include "I2C.h"                        // Rutinas de I2C
  20          
  21          extern BOOL GotSUD;             // Received setup data flag
  22          extern BOOL Sleep;
  23          extern BOOL Rwuen;
  24          extern BOOL Selfpwr;
  25          
  26          BYTE Configuration;             // Current configuration
  27          BYTE AlternateSetting;          // Alternate settings
  28          
  29          /*
  30          xdata BYTE i2cdata[16];
  31          static WORD xdata LED_Count = 0;
  32          static BYTE xdata LED_Status = 0;
  33          */
  34          BOOL in_enable = FALSE;         // flag to enable IN transfers
  35          //-----------------------------------------------------------------------------
  36          // Constants
  37          //-----------------------------------------------------------------------------
  38          /*
  39          #define FRAME_25fps                     0xaa // 40mS  -> Blink
  40          #define FRAME_12_5fps           0xab // 80mS  -> Blink
  41          #define FRAME_6_25fps           0xac // 160mS -> Blink
  42          #define FRAME_3_12fps           0xad // 320mS -> Blink
  43          */
  44          #define SET_PULSADO_ESCOPIA             0xaa // Habilita el disparo por el pedal de escopia
  45          #define SET_PULSADO_CINE                0xab // Habilita el disparo por el pedal de cine
  46          #define SET_TEST_PULSADO                0xac // Prueba de pulsado autogenerado sin escopia
  47          #define SET_FPS_PULSADO                 0xad // FPS en pulsado autogenerado
  48          #define SET_DELTA_MAS                   0xae // DELTA MAS       
  49          #define SET_DELTA_MENOS                 0xaf // DELTA MENOS
  50          #define SET_DELTA                               0xb5 // DELTA SET
  51          #define SET_SYNC_SOURCE                 0xb6 // Tipo de SYNC SET
  52          #define SET_ANCHO_PULSO                 0xb7 // Ancho del Pulso
  53          
  54          #define SET_ESTADO_RELE_AUX3    0xb8 // Fija el estado del Rele Aux 3
  55          #define SET_ESTADO_RELE_IRIS    0xb9 // Fija el estado del Rele Iris
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 2   

  56          #define SET_ESTADO_RELE_HCINE   0xba // Fija el estado del Rele HCINE
  57          #define SET_ESTADO_AUXOUT               0xbb // Fija el estado del puerto AUXOUT
  58          
  59          #define GET_ESTADO_PEDALES              0xbc // Obtener estado de los pedales
  60          #define GET_ESTADO_READY                0xbd // Obtener estado de la señal Ready
  61          #define GET_ESTADO_AUXIN                0xbe // Obtener estado de la señal AUXIN
  62          #define GET_ESTADO_VSYNC                0xbf // Obtener estado de la señal VSYNC
  63          #define GET_ESTADO_CAMPO                0xc0 // Obtener estado de la señal Campo
  64          
  65          #define SET_DIR_PUERTO_B_LIBRE  0xc1 // Fija el comportamiento del puerto B (entrada/salida) de los 3 puer
             -tos no utilizados. 
  66          #define SET_PUERTO_B_LIBRE              0xc2 // Fija el estado del puerto B de los 3 puertos no utilizados. 
  67          #define SET_DIR_PUERTO_A                0xc3 // Fija el comportamiento del puerto A (entrada/salida).
  68          #define SET_PUERTO_A                    0xc4 // Fija el estado del puerto A. 
  69          
  70          #define GET_ESTADO_PUERTO_B             0xc5 // Obtener estado del puerto B.
  71          #define GET_ESTADO_PUERTO_A             0xc6 // Obtener estado del puerto A.
  72          
  73          #define SET_MODO_AUTO_GAIN      0xc7 // Fija que puertos se usarán como indicadores de Ganancia Automática 
             -=> Modo 1: PD5 (TriggerOut se descarta!) y PD6 (AuxOut); Modo 2: PB5 (IOB5) y PB6 (IOB6)
  74          #define SET_PUERTO_AUTO_GAIN    0xc8
  75          #define SET_ANALOG_AUTO_GAIN    0xc9 // Fija el valor del DAC
  76          
  77          //--------------- Tipo de Sincronismo ------------------//
  78          #define PULSO_EXTERNO                           0
  79          #define PULSO_CAMPO                                     1
  80          #define PULSO_VERTICAL                          2
  81          #define PULSO_AUTOGENERADO                      3
  82          #define PULSO_DESHABILITADO                     4
  83          #define PULSO_EXTERNO_2                         5
  84          //--------------- Tipo de Sincronismo ------------------//
  85          
  86          //----------- Estado PULSADA --------------------------//
  87          #define ESTADO_PULSADA_IDLE                     0
  88          #define ESTADO_PULSADA_DESPLAZADO       1       //Espera la cantidad de ticks asignados en estado bajo y pone en estad
             -o alto el puerto antes de pasar a otro estado
  89          #define ESTADO_PULSADA_OFF                      2       //Vuelve al estado bajo
  90          #define ESTADO_PULSADA_ESPERA           3       //Espera a que el pulso recibido se encuentre en estado bajo
  91          //----------- Estado PULSADA --------------------------//
  92          
  93          //----------- Pedales y estados -----------------------//
  94          #define PEDAL_SCOPIA    0
  95          #define PEDAL_GRABAMEM  1
  96          #define PEDAL_CINE              2
  97                  #define ESTADO_PEDAL_IDLE                           0
  98                  #define ESTADO_PEDAL_POSIBLE_PRESIONADO             1
  99                  #define ESTADO_PEDAL_POSIBLE_PRESIONADO_A_CONFIRMAR 2
 100                  #define ESTADO_PEDAL_PRESIONADO                     3
 101          
 102          #define NIVEL_PEDAL_PRESIONADO  0
 103          //----------- Pedales y estados -----------------------//
 104                  
 105          //----------- Auto Gain -------------------------------//
 106          #define AUTO_GAIN_OFF   0
 107          #define AUTO_GAIN_1             1
 108          #define AUTO_GAIN_2             2
 109          //----------- Auto Gain -------------------------------//
 110          
 111          sbit CINE = IOB ^ 0;                    // Señal de cine que viene de la pedalera (Entrada)
 112          sbit SCOPIA = IOB ^ 1;                  // Señal de scopia que viene de la pedalera (Entrada)
 113          sbit AUXIN = IOB ^ 2;                   // Señal auxiliar que viene del equipo de Rayos (Entrada)
 114          sbit TRIGGER_EXT = IOB ^ 3;             // Señal de trigger que viene del equipo de Rayos (Entrada)
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 3   

 115          sbit GRABMEM = IOB ^ 4;                 // Señal de grabación de imagen que viene de la pedalera (Entrada)
 116          sbit PORTB_5 = IOB ^ 5;
 117          sbit PORTB_6 = IOB ^ 6;
 118          sbit PORTB_7 = IOB ^ 7;
 119          
 120          sbit CAMPO      = IOD ^ 0;                      // Señal de campo que se obtiene de la señal de video mediante la placa de interfa
             -z (Entrada)
 121          sbit VSYNC      = IOD ^ 1;                      // Señal del sincronismo vertical que se obtiene de la señal de video mediante la 
             -placa de interfaz (Entrada)
 122          sbit RELE_AUX3  = IOD ^ 2;              // Señal para conmutar el Rele auxiliar 3 (Salida)
 123          sbit RELE_IRIS  = IOD ^ 3;              // Señal para conmutar el Rele Iris (Salida)
 124          sbit RELE_HCINE = IOD ^ 4;              // Señal para conmutar el Rele HCine (Salida)
 125          sbit TRIGGER_OUT = IOD ^ 5;             // Señal de trigger para la cámara (Salida)
 126          sbit AUXOUT = IOD ^ 6;                  // Señal auxiliar (Salida)
 127          sbit READY = IOD ^ 7;                   // Señal ready que viene del equipo de Rayos (Entrada)
 128          
 129          //-----------------------------------------------------------------------------
 130          // Global Variables
 131          //-----------------------------------------------------------------------------
 132          WORD    packetSize;
 133          unsigned int tiempo_ref_fps=20; //20 mSeg
 134          
 135          unsigned int timer0_tick=0;
 136          unsigned int timer1_tick=0;
 137          unsigned int timer1_delay_disparo=0;
 138          unsigned int timer1_tiempo_on_disparo=0;
 139          unsigned int timer1_tiempo_on_disparo_retrasado=0;
 140          
 141          unsigned int delta_tick_1=1;
 142          unsigned int tiempo_on_salida_pulsada=5; //5mSeg => Base de tiempo 1mS
 143          unsigned char estado_salida_pulsada=ESTADO_PULSADA_IDLE;
 144          unsigned char estado_pedales[3]={ESTADO_PEDAL_IDLE, ESTADO_PEDAL_IDLE, ESTADO_PEDAL_IDLE};
 145          
 146          unsigned char origen_pulso_entrada=PULSO_EXTERNO;
 147          unsigned char modo_auto_gain=AUTO_GAIN_OFF;
 148          unsigned char test_disparo=0;
 149          unsigned char disparo_por_escopia=0;
 150          unsigned char disparo_por_cine=0;
 151          unsigned char estado_disparo_latch=1;
 152                                                                                                                                  
 153          //-----------------------------------------------------------------------------
 154          // Prototypes
 155          //-----------------------------------------------------------------------------
 156          void timer0_init (void);
 157          void timer1_init (void);
 158          void InicializarPuertos(void);
 159          void AntiRebotePedales(unsigned char pedal);
 160          
 161          //-----------------------------------------------------------------------------
 162          //INTERRUPCIONES
 163          //-----------------------------------------------------------------------------
 164          
 165          
 166          //-----------------------------------------------------------------------------
 167          // Task Dispatcher hooks
 168          //   The following hooks are called by the task dispatcher.
 169          //-----------------------------------------------------------------------------
 170          void TD_Init(void)             // Called once at startup
 171          {
 172   1              // set the CPU clock to 48MHz
 173   1              CPUCS = ((CPUCS & ~bmCLKSPD) | bmCLKSPD1);
 174   1              
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 4   

 175   1              InicializarPuertos();
 176   1                      
 177   1              timer0_init ();
 178   1              timer1_init (); 
 179   1      }
 180          
 181          void TD_Poll(void)              // Called repeatedly while the device is idle
 182          {               
 183   1              //-------------------------------- Pedaleras  ------------------------------//
 184   1              if(timer0_tick>=1)
 185   1              {
 186   2                      AntiRebotePedales(PEDAL_SCOPIA);                
 187   2                      AntiRebotePedales(PEDAL_GRABAMEM);
 188   2                      AntiRebotePedales(PEDAL_CINE);                          
 189   2      
 190   2                      timer0_tick=0;
 191   2              }       
 192   1              //-------------------------------- Pedaleras  ------------------------------//
 193   1      
 194   1              if(modo_auto_gain!=AUTO_GAIN_1) //Deshabilita el puerto de disparo en caso de usar el modo de Auto Gananc
             -ia en 1
 195   1              {
 196   2                      //------------ Señal de disparo a la cámara con retardo configurable ------//
 197   2                      switch(estado_salida_pulsada)
 198   2                      {       
 199   3                              case ESTADO_PULSADA_IDLE:
 200   3                              {
 201   4                                      switch(origen_pulso_entrada)
 202   4                                      {
 203   5                                              case PULSO_EXTERNO:
 204   5                                              {
 205   6                                                      if(TRIGGER_EXT)
 206   6                                                      {
 207   7                                                              timer1_tick=0;
 208   7                                                              timer1_tiempo_on_disparo=0;
 209   7                                                              timer1_delay_disparo=0;
 210   7                                                              estado_salida_pulsada=ESTADO_PULSADA_DESPLAZADO;                                                        
 211   7                                                      }
 212   6              
 213   6                                                      break;
 214   6                                              }
 215   5              
 216   5                                              case PULSO_CAMPO:
 217   5                                              {
 218   6                                                      if(CAMPO && ((estado_pedales[PEDAL_SCOPIA]==ESTADO_PEDAL_PRESIONADO)||(estado_pedales[PEDAL_CINE]==E
             -STADO_PEDAL_PRESIONADO)))
 219   6                                                      //if(CAMPO && ((estado_pedales[PEDAL_SCOPIA]==ESTADO_PEDAL_PRESIONADO)||(estado_pedales[PEDAL_CINE]=
             -=ESTADO_PEDAL_PRESIONADO)))
 220   6                                                      //if(CAMPO)
 221   6                                                      {                                                       
 222   7                                                              timer1_tick=0;
 223   7                                                              timer1_tiempo_on_disparo=0;
 224   7                                                              timer1_delay_disparo=0; 
 225   7                                                              TRIGGER_OUT=1; //Salida de Trigger para el equipo de Rayos                                                                                                                      
 226   7                                                              estado_salida_pulsada=ESTADO_PULSADA_DESPLAZADO;                                                                                                        
 227   7                                                      }
 228   6              
 229   6                                                      break;
 230   6                                              }
 231   5                                     
 232   5                                              case PULSO_VERTICAL:
 233   5                                              {
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 5   

 234   6                                                      if(!VSYNC && ((estado_pedales[PEDAL_SCOPIA]==ESTADO_PEDAL_PRESIONADO)||(estado_pedales[PEDAL_CINE]==
             -ESTADO_PEDAL_PRESIONADO)))
 235   6                                                      //if(!VSYNC && (estado_pedales[PEDAL_SCOPIA]==ESTADO_PEDAL_PRESIONADO||estado_pedales[PEDAL_CINE]==E
             -STADO_PEDAL_PRESIONADO))
 236   6                                                      {
 237   7                                                              timer1_tick=0;
 238   7                                                              timer1_tiempo_on_disparo=0;
 239   7                                                              timer1_delay_disparo=0; 
 240   7                                                              TRIGGER_OUT=1; //Salida de Trigger para el equipo de Rayos                                                                                                                      
 241   7                                                              estado_salida_pulsada=ESTADO_PULSADA_DESPLAZADO;                                                                                                        
 242   7                                                      }
 243   6              
 244   6                                                      break;
 245   6                                              }
 246   5      
 247   5                                              case PULSO_AUTOGENERADO:
 248   5                                              {
 249   6                                                      if(((estado_pedales[PEDAL_SCOPIA]==ESTADO_PEDAL_PRESIONADO)&&(disparo_por_escopia))||((estado_pedale
             -s[PEDAL_CINE]==ESTADO_PEDAL_PRESIONADO)&&disparo_por_cine)||(test_disparo))
 250   6                                                      {
 251   7                                                              if(timer1_tick>=tiempo_ref_fps)
 252   7                                                              {
 253   8                                                                      timer1_tick=0;
 254   8                                                                      timer1_tiempo_on_disparo=0;
 255   8                                                                      timer1_delay_disparo=0;                                                         
 256   8                                                                      estado_salida_pulsada=ESTADO_PULSADA_DESPLAZADO;
 257   8                                                                      TRIGGER_OUT=1; //Salida de Trigger para el equipo de Rayos                                                                                                                      
 258   8                                                              }
 259   7                                                      }
 260   6      
 261   6                                                      break;
 262   6                                              }
 263   5      
 264   5                                              case PULSO_EXTERNO_2:
 265   5                                              {
 266   6                                                      if(!TRIGGER_EXT)
 267   6                                                      {
 268   7                                                              timer1_tick=0;
 269   7                                                              timer1_tiempo_on_disparo=0;
 270   7                                                              timer1_delay_disparo=0; 
 271   7                                                              //disparo_externo_2_latch=0;                                            
 272   7                                                              //TRIGGER_OUT=1; //Salida de Trigger para probar
 273   7                                                              estado_salida_pulsada=ESTADO_PULSADA_DESPLAZADO;                                                                                                                
 274   7                                                      }
 275   6      
 276   6                                                      break;
 277   6                                              }
 278   5                                      }
 279   4                      
 280   4                                      break;
 281   4                              }
 282   3              
 283   3                              case ESTADO_PULSADA_DESPLAZADO:
 284   3                              {
 285   4                                      switch(origen_pulso_entrada)
 286   4                                      {
 287   5                                              default:
 288   5                                              {
 289   6                                                      //----------------- Delay trigger cámara ------------------//
 290   6                                                      if(timer1_delay_disparo>=delta_tick_1)
 291   6                                                      {
 292   7                                                              estado_salida_pulsada=ESTADO_PULSADA_OFF;       
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 6   

 293   7                                                              AUXOUT=1;
 294   7                                                              
 295   7                                                              //TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos
 296   7                                                              timer1_tiempo_on_disparo_retrasado=0;                                           
 297   7                                                      }                               
 298   6                                                      //----------------- Delay trigger cámara ------------------//
 299   6                                                      
 300   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 301   6                                                      if(timer1_tiempo_on_disparo>=tiempo_on_salida_pulsada)
 302   6                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos                                      
 303   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 304   6                                                              
 305   6                                                      break;
 306   6                                              }
 307   5      
 308   5                                              case PULSO_EXTERNO_2:
 309   5                                              {
 310   6                                                      if(timer1_delay_disparo>=delta_tick_1)
 311   6                                                      {
 312   7                                                              estado_disparo_latch=0;
 313   7                                                              timer1_tiempo_on_disparo_retrasado=0;
 314   7                                                          estado_salida_pulsada=ESTADO_PULSADA_OFF;
 315   7                                                              TRIGGER_OUT=1;
 316   7                                                      }
 317   6                                                      break;
 318   6                                              }
 319   5      
 320   5                                              case PULSO_CAMPO:
 321   5                                              {
 322   6                                                      //----------------- Delay trigger cámara ------------------//
 323   6                                                      if(timer1_delay_disparo>=delta_tick_1)
 324   6                                                      {
 325   7                                                              AUXOUT=1;                                                       
 326   7                                                              timer1_tiempo_on_disparo_retrasado=0;                                           
 327   7                                                              estado_disparo_latch=0;
 328   7                                                              estado_salida_pulsada=ESTADO_PULSADA_OFF;
 329   7                                                      }                               
 330   6                                                      //----------------- Delay trigger cámara ------------------//
 331   6                                                      
 332   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 333   6                                                      if(timer1_tiempo_on_disparo>=tiempo_on_salida_pulsada)
 334   6                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos                                      
 335   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 336   6      
 337   6                                                      break;
 338   6                                              }
 339   5      
 340   5                                              case PULSO_VERTICAL:
 341   5                                              {
 342   6                                                      //----------------- Delay trigger cámara ------------------//
 343   6                                                      if(timer1_delay_disparo>=delta_tick_1)
 344   6                                                      {
 345   7                                                              AUXOUT=1;                                                       
 346   7                                                              //TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos
 347   7                                                              timer1_tiempo_on_disparo_retrasado=0;                                           
 348   7                                                              estado_disparo_latch=0;
 349   7                                                              estado_salida_pulsada=ESTADO_PULSADA_OFF;
 350   7                                                      }                               
 351   6                                                      //----------------- Delay trigger cámara ------------------//
 352   6                                                      
 353   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 354   6                                                      if(timer1_tiempo_on_disparo>=tiempo_on_salida_pulsada)
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 7   

 355   6                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos                                      
 356   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 357   6      
 358   6                                                      break;
 359   6                                              }
 360   5                                      }
 361   4                                                                      
 362   4                                      break;
 363   4                              }
 364   3              
 365   3                              case ESTADO_PULSADA_OFF:
 366   3                              {
 367   4                                      switch(origen_pulso_entrada)
 368   4                                      {
 369   5                                              default:
 370   5                                              {
 371   6                                                      //----------------- Tiempo en On Trigger Cámara --------------//
 372   6                                                      if(timer1_tiempo_on_disparo_retrasado>=tiempo_on_salida_pulsada)
 373   6                                                      {
 374   7                                                              AUXOUT=0;       
 375   7                                                              estado_salida_pulsada=ESTADO_PULSADA_ESPERA;
 376   7                                                              
 377   7                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos                                                              
 378   7                                                      }                               
 379   6                                                      //----------------- Tiempo en On Trigger Cámara --------------//
 380   6                      
 381   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 382   6                                                      if(timer1_tiempo_on_disparo>=tiempo_on_salida_pulsada)
 383   6                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos                                      
 384   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 385   6                                                      break;
 386   6                                              }
 387   5      
 388   5                                              case PULSO_EXTERNO_2:
 389   5                                              {
 390   6                                                      if(timer1_tiempo_on_disparo_retrasado>=(45+tiempo_on_salida_pulsada))
 391   6                                                      {
 392   7                                                              estado_disparo_latch=1;
 393   7                                                              TRIGGER_OUT=0;
 394   7                                                              estado_salida_pulsada=ESTADO_PULSADA_ESPERA;                                            
 395   7                                                      }
 396   6                                                      break;
 397   6                                              }
 398   5      
 399   5                                              case PULSO_CAMPO:
 400   5                                              {
 401   6                                                      if(timer1_tiempo_on_disparo_retrasado>=(20+tiempo_on_salida_pulsada))
 402   6                                                              estado_disparo_latch=1;                                                 
 403   6                                                      
 404   6                                                      //----------------- Tiempo en On Trigger Cámara --------------//
 405   6                                                      if(timer1_tiempo_on_disparo_retrasado>=tiempo_on_salida_pulsada)
 406   6                                                      {
 407   7                                                              AUXOUT=0;       
 408   7                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos
 409   7                                                              estado_salida_pulsada=ESTADO_PULSADA_ESPERA;                                                    
 410   7                                                      }                               
 411   6                                                      //----------------- Tiempo en On Trigger Cámara --------------//
 412   6                      
 413   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 414   6                                                      if(timer1_tiempo_on_disparo>=tiempo_on_salida_pulsada)
 415   6                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos                                      
 416   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 8   

 417   6      
 418   6                                                      break;
 419   6                                              }
 420   5      
 421   5                                              case PULSO_VERTICAL:
 422   5                                              {
 423   6                                                      if(timer1_tiempo_on_disparo_retrasado>=(20+tiempo_on_salida_pulsada))
 424   6                                                              estado_disparo_latch=1;                                                                                                                                                                                                                                 
 425   6                                                      
 426   6                                                      //----------------- Tiempo en On Trigger Cámara --------------//
 427   6                                                      if(timer1_tiempo_on_disparo_retrasado>=tiempo_on_salida_pulsada)
 428   6                                                      {
 429   7                                                              AUXOUT=0;       
 430   7                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos
 431   7                                                              estado_salida_pulsada=ESTADO_PULSADA_ESPERA;                                                    
 432   7                                                      }                               
 433   6                                                      //----------------- Tiempo en On Trigger Cámara --------------//
 434   6                      
 435   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 436   6                                                      if(timer1_tiempo_on_disparo>=tiempo_on_salida_pulsada)
 437   6                                                              TRIGGER_OUT=0; //Salida de Trigger para el equipo de Rayos                                      
 438   6                                                      //----------------- Tiempo en On Trigger Rx --------------//
 439   6      
 440   6                                                      break;
 441   6                                              }
 442   5                                      }
 443   4                                      
 444   4                                      break;
 445   4                              }
 446   3              
 447   3                              case ESTADO_PULSADA_ESPERA:
 448   3                              {
 449   4                                      switch(origen_pulso_entrada)
 450   4                                      {
 451   5                                              case PULSO_EXTERNO:
 452   5                                              {
 453   6                                                      if(!TRIGGER_EXT)
 454   6                                                              estado_salida_pulsada=ESTADO_PULSADA_IDLE;
 455   6                                                      
 456   6                                                      break;
 457   6                                              }
 458   5              
 459   5                                              case PULSO_CAMPO:
 460   5                                              {
 461   6                                                      if(timer1_tiempo_on_disparo_retrasado>=(20+tiempo_on_salida_pulsada))
 462   6                                                              estado_disparo_latch=1;                                                 
 463   6      
 464   6                                                      if(!CAMPO  && (((estado_pedales[PEDAL_SCOPIA]!=ESTADO_PEDAL_PRESIONADO)&&(estado_pedales[PEDAL_CINE]
             -!=ESTADO_PEDAL_PRESIONADO))||(timer1_tick>=(tiempo_ref_fps-5))))
 465   6                                                      //if(!CAMPO)
 466   6                                                      {
 467   7                                                              estado_salida_pulsada=ESTADO_PULSADA_IDLE;
 468   7                                                              estado_disparo_latch=1;
 469   7                                                      }                                                                                                                                               
 470   6                                                                                                                                                      
 471   6                                                      break;
 472   6                                              }
 473   5              
 474   5                                              case PULSO_VERTICAL:
 475   5                                              {
 476   6                                                      if(timer1_tiempo_on_disparo_retrasado>=(20+tiempo_on_salida_pulsada))
 477   6                                                              estado_disparo_latch=1;
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 9   

 478   6      
 479   6                                                      if(VSYNC && (((estado_pedales[PEDAL_SCOPIA]!=ESTADO_PEDAL_PRESIONADO)&&(estado_pedales[PEDAL_CINE]!=
             -ESTADO_PEDAL_PRESIONADO))||(timer1_tick>=(tiempo_ref_fps-5))))
 480   6                                                      {
 481   7                                                              estado_salida_pulsada=ESTADO_PULSADA_IDLE;
 482   7                                                              estado_disparo_latch=1;
 483   7                                                      }
 484   6                                                      else
 485   6                                                              estado_disparo_latch=0;                         
 486   6              
 487   6                                                      break;
 488   6                                              }
 489   5      
 490   5                                              case PULSO_AUTOGENERADO:
 491   5                                              {
 492   6                                                      if((estado_pedales[PEDAL_SCOPIA]!=ESTADO_PEDAL_PRESIONADO)||(estado_pedales[PEDAL_CINE]!=ESTADO_PEDA
             -L_PRESIONADO)||(timer1_tick<tiempo_ref_fps))
 493   6                                                              estado_salida_pulsada=ESTADO_PULSADA_IDLE;                                                                                                              
 494   6      
 495   6                                                      break;
 496   6                                              }
 497   5      
 498   5                                              case PULSO_EXTERNO_2:
 499   5                                              {
 500   6                                                      if(TRIGGER_EXT)
 501   6                                                      {
 502   7                                                              estado_salida_pulsada=ESTADO_PULSADA_IDLE;
 503   7                                                              estado_disparo_latch=1;
 504   7                                                      }
 505   6                                                      else
 506   6                                                              estado_disparo_latch=0;
 507   6      
 508   6                                                      break;
 509   6                                              }
 510   5                                      }
 511   4                                                      
 512   4                                      break;
 513   4                              }
 514   3                      }
 515   2                      //------------ Señal de disparo a la cámara con retardo configurable ------//   
 516   2              }//if(modo_auto_gain!=AUTO_GAIN_1)                      
 517   1      }
 518          
 519          BOOL TD_Suspend(void)          // Called before the device goes into suspend mode
 520          {
 521   1         return(TRUE);
 522   1      }
 523          
 524          BOOL TD_Resume(void)          // Called after the device resumes
 525          {
 526   1         return(TRUE);
 527   1      }
 528          
 529          //-----------------------------------------------------------------------------
 530          // Device Request hooks
 531          //   The following hooks are called by the end point 0 device request parser.
 532          //-----------------------------------------------------------------------------
 533          
 534          BOOL DR_GetDescriptor(void)
 535          {
 536   1         return(TRUE);
 537   1      }
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 10  

 538          
 539          BOOL DR_SetConfiguration(void)   // Called when a Set Configuration command is received
 540          {
 541   1         Configuration = SETUPDAT[2];
 542   1         return(TRUE);            // Handled by user code
 543   1      }
 544          
 545          BOOL DR_GetConfiguration(void)   // Called when a Get Configuration command is received
 546          {
 547   1         EP0BUF[0] = Configuration;
 548   1         EP0BCH = 0;
 549   1         EP0BCL = 1;
 550   1         return(TRUE);            // Handled by user code
 551   1      }
 552          
 553          BOOL DR_SetInterface(void)       // Called when a Set Interface command is received
 554          {
 555   1         AlternateSetting = SETUPDAT[2];
 556   1         return(TRUE);            // Handled by user code
 557   1      }
 558          
 559          BOOL DR_GetInterface(void)       // Called when a Set Interface command is received
 560          {
 561   1         EP0BUF[0] = AlternateSetting;
 562   1         EP0BCH = 0;
 563   1         EP0BCL = 1;
 564   1         return(TRUE);            // Handled by user code
 565   1      }
 566          
 567          BOOL DR_GetStatus(void)
 568          {
 569   1         return(TRUE);
 570   1      }
 571          
 572          BOOL DR_ClearFeature(void)
 573          {
 574   1         return(TRUE);
 575   1      }
 576          
 577          BOOL DR_SetFeature(void)
 578          {
 579   1         return(TRUE);
 580   1      }
 581          //-----------------------------------------------------------------------------
 582          //COMANDOS:
 583          //-----------------------------------------------------------------------------
 584          BOOL DR_VendorCmnd(void)
 585          {
 586   1              switch (SETUPDAT[1])
 587   1              {
 588   2                      //------------------- Pulsos Auto-Generados ---------------------------//
 589   2                      /*
 590   2                      case FRAME_25fps:  //0xaa
 591   2                      {
 592   2                              tiempo_ref_fps=40;
 593   2                              *EP0BUF = (tiempo_ref_fps>>8);
 594   2                              *(EP0BUF+1) = (tiempo_ref_fps&0xff);
 595   2                              EP0BCH = 0;
 596   2                              EP0BCL = 2;
 597   2                              EP0CS |= bmHSNAK;
 598   2                              break; 
 599   2                      }
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 11  

 600   2                      case FRAME_12_5fps:     //0xab     
 601   2                      {
 602   2                              tiempo_ref_fps=80;                      
 603   2                              *EP0BUF = (tiempo_ref_fps>>8);
 604   2                              *(EP0BUF+1) = (tiempo_ref_fps&0xff);                                            
 605   2                              EP0BCH = 0;
 606   2                              EP0BCL = 2;
 607   2                              EP0CS |= bmHSNAK;
 608   2                              break;
 609   2                      }
 610   2                      case FRAME_6_25fps:  //0xac
 611   2                      {
 612   2                              tiempo_ref_fps=160;
 613   2                              *EP0BUF = (tiempo_ref_fps>>8);
 614   2                              *(EP0BUF+1) = (tiempo_ref_fps&0xff);
 615   2                              EP0BCH = 0;
 616   2                              EP0BCL = 2;
 617   2                              EP0CS |= bmHSNAK;
 618   2                              break;
 619   2                      }
 620   2                      case FRAME_3_12fps:   //0xad
 621   2                      {
 622   2                              tiempo_ref_fps=320;
 623   2                              *EP0BUF = (tiempo_ref_fps>>8);
 624   2                              *(EP0BUF+1) = (tiempo_ref_fps&0xff);
 625   2                              EP0BCH = 0;
 626   2                              EP0BCL = 2;
 627   2                              EP0CS |= bmHSNAK;
 628   2                              break;
 629   2                      }
 630   2                      */
 631   2                      case SET_PULSADO_ESCOPIA:
 632   2                      {
 633   3                              disparo_por_escopia=SETUPDAT[2];
 634   3      
 635   3                              *EP0BUF = (unsigned char)(disparo_por_escopia); //Devuelve el valor de la variable disparo_por_escopia
 636   3                              EP0BCH = 0;
 637   3                              EP0BCL = 1;
 638   3                              EP0CS |= bmHSNAK;                       
 639   3                              break;
 640   3                      }
 641   2      
 642   2                      case SET_PULSADO_CINE:
 643   2                      {
 644   3                              disparo_por_cine=SETUPDAT[2];
 645   3      
 646   3                              *EP0BUF = (unsigned char)(disparo_por_cine); //Devuelve el valor de la variable disparo_por_cine
 647   3                              EP0BCH = 0;
 648   3                              EP0BCL = 1;
 649   3                              EP0CS |= bmHSNAK;                       
 650   3                              break;
 651   3                      }
 652   2      
 653   2                      case SET_TEST_PULSADO:
 654   2                      {
 655   3                              test_disparo=SETUPDAT[2];
 656   3      
 657   3                              *EP0BUF = (unsigned char)(test_disparo); //Devuelve el valor de la variable test_disparo
 658   3                              EP0BCH = 0;
 659   3                              EP0BCL = 1;
 660   3                              EP0CS |= bmHSNAK;                       
 661   3                              break;
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 12  

 662   3                      }
 663   2      
 664   2                      case SET_FPS_PULSADO:   //0xad
 665   2                      {
 666   3                              switch(SETUPDAT[2])
 667   3                              {
 668   4                                      case 0:{tiempo_ref_fps=40; break;}      //25FPS
 669   4                                      case 1:{tiempo_ref_fps=80; break;}      //12.5FPS
 670   4                                      case 2:{tiempo_ref_fps=160; break;} //6.25FPS
 671   4                                      case 3:{tiempo_ref_fps=320; break;} //3.125FPS
 672   4                                      case 4:{tiempo_ref_fps=33; break;}      //30FPS
 673   4                                      case 5:{tiempo_ref_fps=66; break;}      //15FPS
 674   4                                      case 6:{tiempo_ref_fps=133; break;} //7.5FPS
 675   4                                      case 7:{tiempo_ref_fps=266; break;} //3.75FPS
 676   4                                      default:{tiempo_ref_fps=40; break;}     //25FPS
 677   4                              }
 678   3                              
 679   3                              *EP0BUF = (tiempo_ref_fps>>8);
 680   3                              *(EP0BUF+1) = (tiempo_ref_fps&0xff);
 681   3                              EP0BCH = 0;
 682   3                              EP0BCL = 2;
 683   3                              EP0CS |= bmHSNAK;
 684   3                              break;
 685   3                      }
 686   2                                      
 687   2                      //------------------- Pulsos Auto-Generados ---------------------------//
 688   2                      
 689   2                      //------------------- Corrimiento entre Trigger Recibido/Rx y Trigger Cámara ----//
 690   2                      case SET_DELTA_MAS:
 691   2                      {
 692   3                              delta_tick_1++;
 693   3                              if(delta_tick_1>19)
 694   3                                      delta_tick_1=19;
 695   3      
 696   3                              *EP0BUF = (unsigned char)(delta_tick_1); //Devuelve el valor para saber el desplazamiento actual
 697   3                              EP0BCH = 0;
 698   3                              EP0BCL = 1;
 699   3                              EP0CS |= bmHSNAK;
 700   3                              break;
 701   3                      }
 702   2      
 703   2                      case SET_DELTA_MENOS:
 704   2                      {
 705   3                              delta_tick_1--;
 706   3                              if(delta_tick_1==0)
 707   3                                      delta_tick_1=1;
 708   3      
 709   3                              *EP0BUF = (unsigned char)(delta_tick_1); //Devuelve el valor para saber el desplazamiento actual
 710   3                              EP0BCH = 0;
 711   3                              EP0BCL = 1;
 712   3                              EP0CS |= bmHSNAK;
 713   3                              break;
 714   3                      }
 715   2                      
 716   2                      case SET_DELTA:
 717   2                      {
 718   3                              if((SETUPDAT[2]>=0) && (SETUPDAT[2]<200))
 719   3                                      delta_tick_1=SETUPDAT[2];
 720   3      
 721   3                              *EP0BUF = (unsigned char)(delta_tick_1); //Devuelve el valor para saber el desplazamiento actual
 722   3                              EP0BCH = 0;
 723   3                              EP0BCL = 1;
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 13  

 724   3                              EP0CS |= bmHSNAK;
 725   3                              break;
 726   3                      }               
 727   2                  //------------------- Corrimiento entre Trigger Recibido/Rx y Trigger Cámara ----//
 728   2      
 729   2                      case SET_SYNC_SOURCE:
 730   2                      {
 731   3                              if((SETUPDAT[2]>=0) && (SETUPDAT[2]<=PULSO_EXTERNO_2))
 732   3                                      origen_pulso_entrada=SETUPDAT[2];
 733   3                              else
 734   3                                      origen_pulso_entrada=PULSO_DESHABILITADO;
 735   3      
 736   3                              *EP0BUF = (unsigned char)(origen_pulso_entrada); //Devuelve el valor para saber el desplazamiento actua
             -l                                        
 737   3      
 738   3                              EP0BCH = 0;
 739   3                              EP0BCL = 1;
 740   3                              EP0CS |= bmHSNAK;
 741   3                              break;
 742   3                      }
 743   2      
 744   2                      case SET_ANCHO_PULSO:
 745   2                      {
 746   3                              if((SETUPDAT[2]>=0) && (SETUPDAT[2]<20))
 747   3                                      tiempo_on_salida_pulsada=SETUPDAT[2];
 748   3      
 749   3                              *EP0BUF = (unsigned char)(tiempo_on_salida_pulsada); //Devuelve el valor para saber el desplazamiento a
             -ctual
 750   3                              EP0BCH = 0;
 751   3                              EP0BCL = 1;
 752   3                              EP0CS |= bmHSNAK;
 753   3                              break;
 754   3                      }
 755   2      
 756   2                      case GET_ESTADO_PEDALES:
 757   2                      {
 758   3                              *EP0BUF = estado_pedales[PEDAL_SCOPIA]; //Devuelve el estado de los pedales
 759   3                              *(EP0BUF+1) = estado_pedales[PEDAL_GRABAMEM]; //Devuelve el estado de los pedales
 760   3                              *(EP0BUF+2) = estado_pedales[PEDAL_CINE]; //Devuelve el estado de los pedales
 761   3                              *(EP0BUF+3) = READY; //Devuelve el estado de ready!
 762   3                              *(EP0BUF+4) = estado_disparo_latch;//TRIGGER_EXT; //Devuelve la entrada del trigger externo, Vsync y ca
             -mpo
 763   3                              
 764   3                              EP0BCH = 0;
 765   3                              EP0BCL = 5;
 766   3                              EP0CS |= bmHSNAK;
 767   3                              break;
 768   3                      }
 769   2      
 770   2                      case GET_ESTADO_READY:
 771   2                      {
 772   3                              *EP0BUF = READY; //Devuelve el estado de la señal de Ready
 773   3                              EP0BCH = 0;
 774   3                              EP0BCL = 1;
 775   3                              EP0CS |= bmHSNAK;
 776   3                              break;
 777   3                      }
 778   2      
 779   2                      case GET_ESTADO_AUXIN:
 780   2                      {
 781   3                              *EP0BUF = AUXIN; //Devuelve el estado de la señal de AUXIN
 782   3                              EP0BCH = 0;
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 14  

 783   3                              EP0BCL = 1;
 784   3                              EP0CS |= bmHSNAK;
 785   3                              break;
 786   3                      }
 787   2      
 788   2                      case GET_ESTADO_VSYNC:
 789   2                      {
 790   3                              *EP0BUF = VSYNC; //Devuelve el estado de la señal de VSYNC
 791   3                              EP0BCH = 0;
 792   3                              EP0BCL = 1;
 793   3                              EP0CS |= bmHSNAK;
 794   3                              break;
 795   3                      }
 796   2      
 797   2                      case GET_ESTADO_CAMPO:
 798   2                      {
 799   3                              *EP0BUF = CAMPO; //Devuelve el estado de la señal de CAMPO
 800   3                              EP0BCH = 0;
 801   3                              EP0BCL = 1;
 802   3                              EP0CS |= bmHSNAK;
 803   3                              break;
 804   3                      }
 805   2                      
 806   2                      case SET_ESTADO_RELE_AUX3:
 807   2                      {
 808   3                              RELE_AUX3=SETUPDAT[2];
 809   3                              *EP0BUF = RELE_AUX3; //Devuelve el estado de la señal de RELE_AUX3
 810   3                              EP0BCH = 0;
 811   3                              EP0BCL = 1;
 812   3                              EP0CS |= bmHSNAK;
 813   3                              break;
 814   3                      }
 815   2      
 816   2                      case SET_ESTADO_RELE_IRIS:
 817   2                      {
 818   3                              RELE_IRIS=SETUPDAT[2];
 819   3                              *EP0BUF = RELE_IRIS; //Devuelve el estado de la señal de RELE_IRIS
 820   3                              EP0BCH = 0;
 821   3                              EP0BCL = 1;
 822   3                              EP0CS |= bmHSNAK;
 823   3                              break;
 824   3                      }
 825   2      
 826   2                      case SET_ESTADO_RELE_HCINE:
 827   2                      {
 828   3                              RELE_HCINE=SETUPDAT[2];
 829   3                              *EP0BUF = RELE_HCINE; //Devuelve el estado de la señal de RELE_HCINE
 830   3                              EP0BCH = 0;
 831   3                              EP0BCL = 1;
 832   3                              EP0CS |= bmHSNAK;
 833   3                              break;
 834   3                      }
 835   2      
 836   2                      case SET_ESTADO_AUXOUT:
 837   2                      {
 838   3                              AUXOUT=SETUPDAT[2];
 839   3                              *EP0BUF = AUXOUT; //Devuelve el estado de la señal de AUXOUT
 840   3                              EP0BCH = 0;
 841   3                              EP0BCL = 1;
 842   3                              EP0CS |= bmHSNAK;
 843   3                              break;
 844   3                      }
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 15  

 845   2                      
 846   2                      /*
 847   2                      case SET_DIR_PUERTO_B_LIBRE:
 848   2                      {
 849   2                              OEB=(SETUPDAT[2]&0xE0); //Solo modifica la dirección de los puertos no utilizados!                      
 850   2                              *EP0BUF = OEB; //Devuelve la dirección del puerto B
 851   2                              EP0BCH = 0;
 852   2                              EP0BCL = 1;
 853   2                              EP0CS |= bmHSNAK;
 854   2                              break;
 855   2                      }
 856   2      
 857   2                      case SET_PUERTO_B_LIBRE:
 858   2                      {
 859   2                              PORTB_5=(SETUPDAT[2]&0x20);
 860   2                              PORTB_6=(SETUPDAT[2]&0x40);
 861   2                              PORTB_7=(SETUPDAT[2]&0x80);
 862   2      
 863   2                              *EP0BUF = IOB; //Devuelve el estado del puerto B                        
 864   2                              EP0BCH = 0;
 865   2                              EP0BCL = 1;
 866   2                              EP0CS |= bmHSNAK;
 867   2                              break;
 868   2                      }
 869   2                  
 870   2                      case SET_DIR_PUERTO_A:
 871   2                      {
 872   2                              OEA=SETUPDAT[2]; 
 873   2                              *EP0BUF = OEA; //Devuelve la dirección del puerto A
 874   2                              EP0BCH = 0;
 875   2                              EP0BCL = 1;
 876   2                              EP0CS |= bmHSNAK;
 877   2                              break;
 878   2                      }
 879   2      
 880   2                      case SET_PUERTO_A:
 881   2                      {
 882   2                              IOA=SETUPDAT[2]; 
 883   2                              *EP0BUF = IOA; //Devuelve estado del puerto A
 884   2                              EP0BCH = 0;
 885   2                              EP0BCL = 1;
 886   2                              EP0CS |= bmHSNAK;
 887   2                              break;
 888   2                      }
 889   2                      
 890   2                      case GET_ESTADO_PUERTO_B:
 891   2                      {
 892   2                              *EP0BUF = IOB; //Devuelve el estado de la señal de Ready
 893   2                              EP0BCH = 0;
 894   2                              EP0BCL = 1;
 895   2                              EP0CS |= bmHSNAK;
 896   2                              break;
 897   2                      }
 898   2                      
 899   2                      case GET_ESTADO_PUERTO_A:
 900   2                      {
 901   2                              *EP0BUF = IOA; //Devuelve el estado de la señal de Ready
 902   2                              EP0BCH = 0;
 903   2                              EP0BCL = 1;
 904   2                              EP0CS |= bmHSNAK;
 905   2                              break;
 906   2                      }
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 16  

 907   2                      */
 908   2                      case SET_MODO_AUTO_GAIN:
 909   2                      {
 910   3                              modo_auto_gain=SETUPDAT[2]; 
 911   3                              *EP0BUF = SETUPDAT[2]; //Devuelve el modo de Ganancia Automática
 912   3                              EP0BCH = 0;
 913   3                              EP0BCL = 1;
 914   3                              EP0CS |= bmHSNAK;
 915   3                              
 916   3                              switch(modo_auto_gain)
 917   3                              {
 918   4                                      case AUTO_GAIN_1:
 919   4                                      {
 920   5                                              TRIGGER_OUT=0;
 921   5                                              AUXOUT=0;       
 922   5                                              break;
 923   5                                      }
 924   4      
 925   4                                      case AUTO_GAIN_2:
 926   4                                      {
 927   5                                              OEB |= 0X60; //Puerto B5 y B6 como salidas
 928   5                                              PORTB_5=0;
 929   5                                              PORTB_6=0;
 930   5                                              break;
 931   5                                      }
 932   4                              }
 933   3                              
 934   3                              break;
 935   3                      }
 936   2      
 937   2                      case SET_PUERTO_AUTO_GAIN:
 938   2                      {
 939   3                              switch(modo_auto_gain)
 940   3                              {
 941   4                                      case AUTO_GAIN_1:
 942   4                                      {
 943   5                                              TRIGGER_OUT=SETUPDAT[2];
 944   5                                              AUXOUT=SETUPDAT[3];     
 945   5                                              break;
 946   5                                      }
 947   4      
 948   4                                      case AUTO_GAIN_2:
 949   4                                      {
 950   5                                              PORTB_5=SETUPDAT[2];
 951   5                                              PORTB_6=SETUPDAT[3];
 952   5                                              break;
 953   5                                      }
 954   4                              }
 955   3      
 956   3                              *EP0BUF = SETUPDAT[2]; //Devuelve el estado de los pedales
 957   3                              *(EP0BUF+1) = SETUPDAT[3]; //Devuelve el estado de los pedales
 958   3                              EP0BCH = 0;
 959   3                              EP0BCL = 2;
 960   3                              EP0CS |= bmHSNAK;
 961   3      
 962   3                              break;
 963   3                      }
 964   2      
 965   2                      case SET_ANALOG_AUTO_GAIN:
 966   2                      {
 967   3                              *EP0BUF = SetDAC5571(SETUPDAT[2], SETUPDAT[3]); //Devuelve el resultado de la escritura del I2C, 0: Ok,
             - 1: Error
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 17  

 968   3                              EP0BCH = 0;
 969   3                              EP0BCL = 1;
 970   3                              EP0CS |= bmHSNAK;
 971   3      
 972   3                              break;
 973   3                      }
 974   2      
 975   2                      default:
 976   2                              return(TRUE);
 977   2              }
 978   1              return(FALSE);
 979   1      }
 980          
 981          //-----------------------------------------------------------------------------
 982          // USB Interrupt Handlers
 983          //   The following functions are called by the USB interrupt jump table.
 984          //-----------------------------------------------------------------------------
 985          
 986          // Setup Data Available Interrupt Handler
 987          void ISR_Sudav(void) interrupt 0
 988          {
 989   1         // enable the automatic length feature of the Setup Data Autopointer
 990   1         // in case a previous transfer disbaled it
 991   1         SUDPTRCTL |= bmSDPAUTO;
 992   1         GotSUD = TRUE;            // Set flag
 993   1         EZUSB_IRQ_CLEAR();
 994   1         USBIRQ = bmSUDAV;         // Clear SUDAV IRQ
 995   1      }
 996          
 997          // Setup Token Interrupt Handler
 998          void ISR_Sutok(void) interrupt 0
 999          {
1000   1         EZUSB_IRQ_CLEAR();
1001   1         USBIRQ = bmSUTOK;         // Clear SUTOK IRQ
1002   1      }
1003          
1004          void ISR_Sof(void) interrupt 0
1005          {
1006   1         EZUSB_IRQ_CLEAR();
1007   1         USBIRQ = bmSOF;            // Clear SOF IRQ
1008   1      }
1009          
1010          void ISR_Ures(void) interrupt 0
1011          {
1012   1         if (EZUSB_HIGHSPEED())
1013   1         {
1014   2            pConfigDscr = pHighSpeedConfigDscr;
1015   2            pOtherConfigDscr = pFullSpeedConfigDscr;
1016   2            packetSize = 512;
1017   2      
1018   2         }
1019   1         else
1020   1         {
1021   2            pConfigDscr = pFullSpeedConfigDscr;
1022   2            pOtherConfigDscr = pHighSpeedConfigDscr;
1023   2            packetSize = 64;
1024   2         }
1025   1         
1026   1         EZUSB_IRQ_CLEAR();
1027   1         USBIRQ = bmURES;         // Clear URES IRQ
1028   1      }
1029          
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 18  

1030          void ISR_Susp(void) interrupt 0
1031          {
1032   1         Sleep = TRUE;
1033   1         EZUSB_IRQ_CLEAR();
1034   1         USBIRQ = bmSUSP;
1035   1      }
1036          
1037          void ISR_Highspeed(void) interrupt 0
1038          {
1039   1         if (EZUSB_HIGHSPEED())
1040   1         {
1041   2            pConfigDscr = pHighSpeedConfigDscr;
1042   2            pOtherConfigDscr = pFullSpeedConfigDscr;
1043   2            packetSize = 512;
1044   2      
1045   2         }
1046   1         else
1047   1         {
1048   2            pConfigDscr = pFullSpeedConfigDscr;
1049   2            pOtherConfigDscr = pHighSpeedConfigDscr;
1050   2            packetSize = 64;
1051   2         }
1052   1      
1053   1         EZUSB_IRQ_CLEAR();
1054   1         USBIRQ = bmHSGRANT;
1055   1      }
1056          
1057          // This function enables Timer 0. Timer 0 generates a synchronous interrupt
1058          // once every 100Hz or 10 ms.
1059          void timer0_init (void)
1060          {
1061   1              EA = 0; // disables all interrupts
1062   1              timer0_tick = 0;
1063   1              TR0 = 0; // stops Timer 0
1064   1              CKCON = 0x03; // Timer 0 using CLKOUT/12
1065   1              TMOD &= ~0x0F; // clear Timer 0 mode bits
1066   1              TMOD |= 0x01; // setup Timer 0 as a 16-bit timer
1067   1              TL0 = (TIMER0_COUNT & 0x00FF); // loads the timer counts
1068   1              TH0 = (TIMER0_COUNT >> 8);
1069   1              PT0 = 0; // sets the Timer 0 interrupt to low priority
1070   1              ET0 = 1; // enables Timer 0 interrupt
1071   1              TR0 = 1; // starts Timer 0
1072   1              EA = 1; // enables all interrupts
1073   1      }
1074          
1075          // This function enables Timer 1. Timer 1 generates a synchronous interrupt
1076          // once every 1000Hz or 1 ms.
1077          void timer1_init (void)
1078          {
1079   1              EA = 0; // disables all interrupts
1080   1              timer1_tick = 0;
1081   1              TR1 = 0; // stops Timer 0
1082   1              CKCON = 0x03; // Timer 0 using CLKOUT/12
1083   1              TMOD &= ~0xF0; // clear Timer 1 and 1 mode bits
1084   1              TMOD |= 0x10; // setup Timer 1 as a 16-bit timer
1085   1              TL1 = (TIMER1_COUNT & 0x00FF); // loads the timer counts
1086   1              TH1 = (TIMER1_COUNT >> 8);
1087   1              PT1 = 0; // sets the Timer 0 interrupt to low priority
1088   1              ET1 = 1; // enables Timer 0 interrupt
1089   1              
1090   1              TR1 = 1; // starts Timer 1
1091   1              EA = 1; // enables all interrupts
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 19  

1092   1      }
1093          
1094          void InicializarPuertos()
1095          {
1096   1              /*
1097   1              sbit CINE = IOB ^ 0;                    // Señal de cine que viene de la pedalera (Entrada)
1098   1              sbit SCOPIA = IOB ^ 1;                  // Señal de scopia que viene de la pedalera (Entrada)
1099   1              sbit AUXIN = IOB ^ 2;                   // Señal auxiliar que viene del equipo de Rayos (Entrada)
1100   1              sbit TRIGGER_EXT = IOB ^ 3;             // Señal de trigger que viene del equipo de Rayos (Entrada)
1101   1              sbit GRABMEM = IOB ^ 4;                 // Señal de grabación de imagen que viene de la pedalera (Entrada)
1102   1              sbit LED_TESTIGO = IOB ^ 7;
1103   1              
1104   1              sbit CAMPO      = IOD ^ 0;                      // Señal de campo que se obtiene de la señal de video mediante la placa de interf
             -az (Entrada)
1105   1              sbit VSYNC      = IOD ^ 1;                      // Señal del sincronismo vertical que se obtiene de la señal de video mediante la
             - placa de interfaz (Entrada)
1106   1              sbit RELE_AUX3  = IOD ^ 2;              // Señal para conmutar el Rele auxiliar 3 (Salida)
1107   1              sbit RELE_IRIS  = IOD ^ 3;              // Señal para conmutar el Rele Iris (Salida)
1108   1              sbit RELE_HCINE = IOD ^ 4;              // Señal para conmutar el Rele HCine (Salida)
1109   1              sbit TRIGGER_OUT = IOD ^ 5;             // Señal de trigger para la cámara (Salida)
1110   1              sbit AUXOUT = IOD ^ 6;                  // Señal auxiliar (Salida)
1111   1              sbit READY = IOD ^ 7;                   // Señal ready que viene del equipo de Rayos (Entrada)
1112   1              */
1113   1              
1114   1              //------------ Puerto A ----------------------//
1115   1              OEA=0x00; //Puerto A como entrada
1116   1              //------------ Puerto A ----------------------//
1117   1      
1118   1              //------------ Puerto B ----------------------//        
1119   1              OEB = 0X00; //Puerto B como entrada
1120   1              SCOPIA=1;
1121   1              GRABMEM=1;
1122   1              CINE=1;
1123   1              AUXIN=1;
1124   1              TRIGGER_EXT=1;
1125   1              GRABMEM=1;
1126   1              //------------ Puerto B ----------------------//
1127   1      
1128   1              //------------ Puerto D ----------------------//
1129   1              OED =0X7C; //PD0, PD1 y PD7: entradas; PD2, PD3, PD4, PD5, PD6: salidas
1130   1              CAMPO=1;
1131   1              VSYNC=1;
1132   1              READY=1;
1133   1      
1134   1              RELE_AUX3=0;
1135   1              RELE_IRIS=0;
1136   1              RELE_HCINE=0;
1137   1              TRIGGER_OUT=0;
1138   1              AUXOUT=0;
1139   1              //------------ Puerto D ----------------------//        
1140   1      }
1141          
1142          void AntiRebotePedales(unsigned char pedal)
1143          {
1144   1          bit ret;
1145   1      
1146   1          switch(estado_pedales[pedal])
1147   1          {
1148   2              case ESTADO_PEDAL_IDLE:
1149   2              {
1150   3                  switch(pedal)
1151   3                              {
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 20  

1152   4                                      case PEDAL_SCOPIA:
1153   4                                      {
1154   5                                              ret=SCOPIA;
1155   5                                              break;
1156   5                                      }
1157   4      
1158   4                                      case PEDAL_GRABAMEM:
1159   4                                      {
1160   5                                              ret=GRABMEM;
1161   5                                              break;
1162   5                                      }
1163   4      
1164   4                                      case PEDAL_CINE:
1165   4                                      {
1166   5                                              ret=CINE;
1167   5                                              break;
1168   5                                      }
1169   4                              }
1170   3      
1171   3                  if(ret==NIVEL_PEDAL_PRESIONADO)
1172   3                      estado_pedales[pedal]=ESTADO_PEDAL_POSIBLE_PRESIONADO;
1173   3                  break;
1174   3              }
1175   2      
1176   2              case ESTADO_PEDAL_POSIBLE_PRESIONADO:
1177   2              {
1178   3                  switch(pedal)
1179   3                              {
1180   4                                      case PEDAL_SCOPIA:
1181   4                                      {
1182   5                                              ret=SCOPIA;
1183   5                                              break;
1184   5                                      }
1185   4      
1186   4                                      case PEDAL_GRABAMEM:
1187   4                                      {
1188   5                                              ret=GRABMEM;
1189   5                                              break;
1190   5                                      }
1191   4      
1192   4                                      case PEDAL_CINE:
1193   4                                      {
1194   5                                              ret=CINE;
1195   5                                              break;
1196   5                                      }
1197   4                              }
1198   3      
1199   3                              if(ret==NIVEL_PEDAL_PRESIONADO)
1200   3                      estado_pedales[pedal]=ESTADO_PEDAL_POSIBLE_PRESIONADO_A_CONFIRMAR;           
1201   3                  else
1202   3                      estado_pedales[pedal]=ESTADO_PEDAL_IDLE;   //Rebote
1203   3      
1204   3                  break;
1205   3              }
1206   2      
1207   2              case ESTADO_PEDAL_POSIBLE_PRESIONADO_A_CONFIRMAR:
1208   2              {
1209   3                  switch(pedal)
1210   3                              {
1211   4                                      case PEDAL_SCOPIA:
1212   4                                      {
1213   5                                              ret=SCOPIA;
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 21  

1214   5                                              break;
1215   5                                      }
1216   4      
1217   4                                      case PEDAL_GRABAMEM:
1218   4                                      {
1219   5                                              ret=GRABMEM;
1220   5                                              break;
1221   5                                      }
1222   4      
1223   4                                      case PEDAL_CINE:
1224   4                                      {
1225   5                                              ret=CINE;
1226   5                                              break;
1227   5                                      }
1228   4                              }
1229   3                              
1230   3                              if(ret==NIVEL_PEDAL_PRESIONADO)
1231   3                      estado_pedales[pedal]=ESTADO_PEDAL_PRESIONADO;           
1232   3                  else
1233   3                      estado_pedales[pedal]=ESTADO_PEDAL_IDLE;   //Rebote
1234   3      
1235   3                  break;
1236   3              }
1237   2      
1238   2              case ESTADO_PEDAL_PRESIONADO:
1239   2              {
1240   3                  switch(pedal)
1241   3                              {
1242   4                                      case PEDAL_SCOPIA:
1243   4                                      {
1244   5                                              ret=SCOPIA;
1245   5                                              break;
1246   5                                      }
1247   4      
1248   4                                      case PEDAL_GRABAMEM:
1249   4                                      {
1250   5                                              ret=GRABMEM;
1251   5                                              break;
1252   5                                      }
1253   4      
1254   4                                      case PEDAL_CINE:
1255   4                                      {
1256   5                                              ret=CINE;
1257   5                                              break;
1258   5                                      }
1259   4                              }                       
1260   3      
1261   3                  if(ret!=NIVEL_PEDAL_PRESIONADO)
1262   3                                      estado_pedales[pedal]=ESTADO_PEDAL_IDLE;
1263   3                      
1264   3                  break;
1265   3              }
1266   2          }
1267   1      }
1268          
1269          
1270          void ISR_Ep0ack(void) interrupt 0
1271          {
1272   1      }
1273          void ISR_Stub(void) interrupt 0
1274          {
1275   1      }
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 22  

1276          void ISR_Ep0in(void) interrupt 0
1277          {
1278   1      }
1279          void ISR_Ep0out(void) interrupt 0
1280          {
1281   1      }
1282          void ISR_Ep1in(void) interrupt 0
1283          {
1284   1      }
1285          void ISR_Ep1out(void) interrupt 0
1286          {
1287   1      }
1288          void ISR_Ep2inout(void) interrupt 0
1289          {
1290   1      }
1291          void ISR_Ep4inout(void) interrupt 0
1292          {
1293   1      }
1294          void ISR_Ep6inout(void) interrupt 0
1295          {
1296   1      }
1297          void ISR_Ep8inout(void) interrupt 0
1298          {
1299   1      }
1300          void ISR_Ibn(void) interrupt 0
1301          {
1302   1      }
1303          void ISR_Ep0pingnak(void) interrupt 0
1304          {
1305   1      }
1306          void ISR_Ep1pingnak(void) interrupt 0
1307          {
1308   1      }
1309          void ISR_Ep2pingnak(void) interrupt 0
1310          {
1311   1      }
1312          void ISR_Ep4pingnak(void) interrupt 0
1313          {
1314   1      }
1315          void ISR_Ep6pingnak(void) interrupt 0
1316          {
1317   1      }
1318          void ISR_Ep8pingnak(void) interrupt 0
1319          {
1320   1      }
1321          void ISR_Errorlimit(void) interrupt 0
1322          {
1323   1      }
1324          void ISR_Ep2piderror(void) interrupt 0
1325          {
1326   1      }
1327          void ISR_Ep4piderror(void) interrupt 0
1328          {
1329   1      }
1330          void ISR_Ep6piderror(void) interrupt 0
1331          {
1332   1      }
1333          void ISR_Ep8piderror(void) interrupt 0
1334          {
1335   1      }
1336          void ISR_Ep2pflag(void) interrupt 0
1337          {
C51 COMPILER V8.05a   PEDALERA                                                             04/19/2018 15:18:09 PAGE 23  

1338   1      }
1339          void ISR_Ep4pflag(void) interrupt 0
1340          {
1341   1      }
1342          void ISR_Ep6pflag(void) interrupt 0
1343          {
1344   1      }
1345          void ISR_Ep8pflag(void) interrupt 0
1346          {
1347   1      }
1348          void ISR_Ep2eflag(void) interrupt 0
1349          {
1350   1      }
1351          void ISR_Ep4eflag(void) interrupt 0
1352          {
1353   1      }
1354          void ISR_Ep6eflag(void) interrupt 0
1355          {
1356   1      }
1357          void ISR_Ep8eflag(void) interrupt 0
1358          {
1359   1      }
1360          void ISR_Ep2fflag(void) interrupt 0
1361          {
1362   1      }
1363          void ISR_Ep4fflag(void) interrupt 0
1364          {
1365   1      }
1366          void ISR_Ep6fflag(void) interrupt 0
1367          {
1368   1      }
1369          void ISR_Ep8fflag(void) interrupt 0
1370          {
1371   1      }
1372          void ISR_GpifComplete(void) interrupt 0
1373          {
1374   1      }
1375          void ISR_GpifWaveform(void) interrupt 0
1376          {
1377   1      }
1378          


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =   2138    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   ----    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =     30    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =      1       1
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)
